/**
 * Markdown 内容验证工具
 * 用于检测模板字符串中可能导致语法错误的特殊字符
 */

/**
 * 转义 Markdown 内容，使其可以安全地用于 JavaScript 模板字符串
 * @param {string} content - 原始 Markdown 内容
 * @returns {string} 转义后的内容
 */
export function escapeForTemplate(content) {
  return content
    .replace(/\\/g, '\\\\')    // 转义反斜杠 \ → \\
    .replace(/`/g, '\\`')      // 转义反引号 ` → \`
    .replace(/\${/g, '\\${');  // 转义模板表达式 ${ → \${
}

/**
 * 反转义内容（从模板字符串中读取后使用）
 * @param {string} content - 转义后的内容
 * @returns {string} 原始内容
 */
export function unescapeFromTemplate(content) {
  return content
    .replace(/\\\${/g, '${')   // 反转义模板表达式
    .replace(/\\`/g, '`')      // 反转义反引号
    .replace(/\\\\/g, '\\');   // 反转义反斜杠（最后处理）
}

/**
 * 验证 Markdown 内容是否包含需要转义的特殊字符
 * @param {string} content - 要验证的 Markdown 内容
 * @returns {Object} 验证结果
 */
export function validateMarkdownContent(content) {
  const issues = [];
  
  // 检查未转义的反引号（排除代码块中的）
  const backticksOutsideCode = content.match(/(?<!\\)`(?!``)/g);
  if (backticksOutsideCode) {
    issues.push({
      type: 'unescaped_backtick',
      message: `发现 ${backticksOutsideCode.length} 个未转义的反引号 \``,
      severity: 'error',
      suggestion: '使用 \\` 转义反引号'
    });
  }
  
  // 检查未转义的模板表达式
  const unescapedTemplate = content.match(/(?<!\\)\$\{/g);
  if (unescapedTemplate) {
    issues.push({
      type: 'unescaped_template',
      message: `发现 ${unescapedTemplate.length} 个未转义的模板表达式 \${`,
      severity: 'error',
      suggestion: '使用 \\${ 转义模板表达式'
    });
  }
  
  // 检查单个反斜杠（可能需要转义）
  const singleBackslash = content.match(/(?<!\\)\\(?!\\|`|\$)/g);
  if (singleBackslash) {
    issues.push({
      type: 'single_backslash',
      message: `发现 ${singleBackslash.length} 个可能需要转义的反斜杠 \\`,
      severity: 'warning',
      suggestion: '如果不是有意为之，使用 \\\\ 转义反斜杠'
    });
  }
  
  return {
    isValid: issues.filter(i => i.severity === 'error').length === 0,
    hasWarnings: issues.filter(i => i.severity === 'warning').length > 0,
    issues,
    summary: issues.length === 0 
      ? '✅ 内容安全，无需转义' 
      : `⚠️ 发现 ${issues.length} 个问题`
  };
}

/**
 * 自动修复内容中的转义问题
 * @param {string} content - 原始内容
 * @returns {Object} 修复结果
 */
export function autoFixContent(content) {
  const original = content;
  const fixed = escapeForTemplate(content);
  const changes = [];
  
  if (original !== fixed) {
    // 统计变更
    const backtickChanges = (fixed.match(/\\`/g) || []).length - (original.match(/\\`/g) || []).length;
    const templateChanges = (fixed.match(/\\\${/g) || []).length - (original.match(/\\\${/g) || []).length;
    const backslashChanges = (fixed.match(/\\\\\\\\/g) || []).length - (original.match(/\\\\\\\\/g) || []).length;
    
    if (backtickChanges > 0) changes.push(`转义了 ${backtickChanges} 个反引号`);
    if (templateChanges > 0) changes.push(`转义了 ${templateChanges} 个模板表达式`);
    if (backslashChanges > 0) changes.push(`转义了 ${backslashChanges} 个反斜杠`);
  }
  
  return {
    original,
    fixed,
    changed: original !== fixed,
    changes
  };
}

/**
 * 批量验证文档对象数组
 * @param {Array} documents - 文档对象数组
 * @returns {Object} 批量验证结果
 */
export function validateDocuments(documents) {
  const results = documents.map(doc => {
    const validation = validateMarkdownContent(doc.content || '');
    return {
      id: doc.id,
      title: doc.title,
      ...validation
    };
  });
  
  const errorDocs = results.filter(r => !r.isValid);
  const warningDocs = results.filter(r => r.isValid && r.hasWarnings);
  
  return {
    total: documents.length,
    errors: errorDocs.length,
    warnings: warningDocs.length,
    safe: documents.length - errorDocs.length - warningDocs.length,
    errorDocuments: errorDocs,
    warningDocuments: warningDocs,
    allValid: errorDocs.length === 0
  };
}

/**
 * 生成验证报告（用于开发时检查）
 * @param {Array} documents - 文档对象数组
 */
export function generateValidationReport(documents) {
  console.group('📋 Markdown 内容验证报告');
  
  const validation = validateDocuments(documents);
  
  console.log(`总文档数: ${validation.total}`);
  console.log(`✅ 安全: ${validation.safe}`);
  console.log(`⚠️ 警告: ${validation.warnings}`);
  console.log(`❌ 错误: ${validation.errors}`);
  
  if (validation.errorDocuments.length > 0) {
    console.group('❌ 有错误的文档:');
    validation.errorDocuments.forEach(doc => {
      console.group(`📄 ${doc.title} (ID: ${doc.id})`);
      doc.issues.forEach(issue => {
        console.error(`${issue.severity}: ${issue.message}`);
        console.log(`💡 建议: ${issue.suggestion}`);
      });
      console.groupEnd();
    });
    console.groupEnd();
  }
  
  if (validation.warningDocuments.length > 0) {
    console.group('⚠️ 有警告的文档:');
    validation.warningDocuments.forEach(doc => {
      console.group(`📄 ${doc.title} (ID: ${doc.id})`);
      doc.issues.forEach(issue => {
        console.warn(`${issue.severity}: ${issue.message}`);
      });
      console.groupEnd();
    });
    console.groupEnd();
  }
  
  console.groupEnd();
  
  return validation;
}

// 示例使用
if (import.meta.env.DEV) {
  // 在开发环境中，可以导出一个全局验证函数
  window.__validateMarkdown = {
    validate: validateMarkdownContent,
    escape: escapeForTemplate,
    autoFix: autoFixContent,
    generateReport: generateValidationReport
  };
}

